home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 7 / Amiga Format AFCD07 (Dec 1996, Issue 91).iso / serious / shareware / programming / ixemul-complete / ixemul / general / arith.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-13  |  12.6 KB  |  777 lines
  1. #define ALL
  2.  
  3. #include "common.h"
  4. #include "defs.h"
  5. #include <proto/mathieeedoubbas.h>
  6. #include <proto/mathieeedoubtrans.h>
  7. #include <proto/mathieeesingbas.h>
  8.  
  9. /*  Special patch to work around bug in IEEEDPCmp:
  10.  *  if the first 32 bits of both doubles are equal, and
  11.  *  both doubles are negative, then the result can no longer
  12.  *  be trusted.
  13.  * 
  14.  *  This is the output of a small test program:
  15.  *
  16.  *    test -2.000001 -2.0000009
  17.  *    a = -2.0000009999999996956888, b = -2.0000008999999998593466
  18.  *    (0xc0000000 0x8637bd05, 0xc0000000 0x78cbc3b8)
  19.  *    cmp(a,b) = 0, cmp(b,a) = 1
  20.  *
  21.  *    test -2.0000001 -2.0000002
  22.  *    a = -2.00000009999999983634211, b = -2.0000001999999996726842
  23.  *    (0xc0000000 0xd6bf94d, 0xc0000000 0x1ad7f29a)
  24.  *    cmp(a,b) = 1, cmp(b,a) = 1
  25.  *
  26.  *  As you can see, the results are wrong.
  27.  *
  28.  *  So, we just make both variables positive and exchange them before
  29.  *  passing them to IEEEDPCmp.
  30.  *
  31.  *  This bug was discovered by Bart Van Assche, thanks!
  32.  */
  33.  
  34. static int ieeedpcmp(double a, double b)
  35. {
  36.   if (*((char *)&a) & *((char *)&b) & 0x80)  /* both doubles negative? */
  37.     {
  38.       *((char *)&a) &= 0x7f;    /* yes, make positive */
  39.       *((char *)&b) &= 0x7f;
  40.       return IEEEDPCmp(b, a);   /* pass them to IEEEDPCmp the other way round */
  41.     }
  42.   return IEEEDPCmp(a, b);
  43. }
  44.  
  45. #if defined(L__eqdf2) || defined(ALL)
  46. int __eqdf2 (double a, double b)
  47. {
  48.   return ieeedpcmp (a, b);
  49. }
  50. #endif
  51.  
  52. #if defined(L__eqsf2) || defined(ALL)
  53. int __eqsf2 (FLOAT a, FLOAT b)
  54. {
  55.   return IEEESPCmp (a, b);
  56. }
  57. #endif
  58.  
  59. #if defined(L__fixsfsi) || defined(ALL)
  60. SItype __fixsfsi (FLOAT a)
  61. {
  62.   return IEEESPFix(a);
  63. }
  64. #endif
  65.  
  66. #if defined(L__floatsisf) || defined(ALL)
  67. SFVALUE __floatsisf (SItype a)
  68. {
  69.   return IEEESPFlt(a);
  70. }
  71. #endif
  72.  
  73. #if defined(L__gedf2) || defined(ALL)
  74. int __gedf2 (double a, double b)
  75. {
  76.   return ieeedpcmp (a, b);
  77. }
  78. #endif
  79.  
  80. #if defined(L__gesf2) || defined(ALL)
  81. int __gesf2 (FLOAT a, FLOAT b)
  82. {
  83.   return IEEESPCmp (a, b);
  84. }
  85. #endif
  86.  
  87. #if defined(L__gtdf2) || defined(ALL)
  88. int __gtdf2 (double a, double b)
  89. {
  90.   return ieeedpcmp (a, b);
  91. }
  92. #endif
  93.  
  94. #if defined(L__gtsf2) || defined(ALL)
  95. int __gtsf2 (FLOAT a, FLOAT b)
  96. {
  97.   return IEEESPCmp (a, b);
  98. }
  99. #endif
  100.  
  101. #if defined(L__ledf2) || defined(ALL)
  102. int __ledf2 (double a, double b)
  103. {
  104.   return ieeedpcmp (a, b);
  105. }
  106. #endif
  107.  
  108. #if defined(L__lesf2) || defined(ALL)
  109. int __lesf2 (FLOAT a, FLOAT b)
  110. {
  111.   return IEEESPCmp (a, b);
  112. }
  113. #endif
  114.  
  115. #if defined(L__ltdf2) || defined(ALL)
  116. int __ltdf2 (double a, double b)
  117. {
  118.   return ieeedpcmp (a, b);
  119. }
  120. #endif
  121.  
  122. #if defined(L__ltsf2) || defined(ALL)
  123. int __ltsf2 (FLOAT a, FLOAT b)
  124. {
  125.   return IEEESPCmp (a, b);
  126. }
  127. #endif
  128.  
  129. #if defined(L__nedf2) || defined(ALL)
  130. int __nedf2 (double a, double b)
  131. {
  132.   return !!ieeedpcmp (a, b);
  133. }
  134. #endif
  135.  
  136. #if defined(L__nesf2) || defined(ALL)
  137. int __nesf2 (FLOAT a, FLOAT b)
  138. {
  139.   return !!IEEESPCmp (a, b);
  140. }
  141. #endif
  142.  
  143.  
  144.  
  145.  
  146. #if defined (mc68020) || defined (mc68030) || defined (mc68040) || defined (mc68060)
  147.  
  148. /* int / int */
  149. #if defined(L__divsi3) || defined(ALL)
  150. ENTRY(__divsi3)
  151. asm("
  152.     movel    sp@(4),d0
  153.     divsl    sp@(8),d0
  154.     rts
  155. ");
  156. #endif
  157.  
  158. /* int % int */
  159. #if defined(L__modsi3) || defined(ALL)
  160. ENTRY(__modsi3)
  161. asm("
  162.     movel    sp@(4),d1
  163.     divsll    sp@(8),d0:d1
  164.     rts
  165. ");
  166. #endif
  167.  
  168. /* int * int */
  169. #if defined(L__mulsi3) || defined(ALL)
  170. ENTRY(__mulsi3)
  171. asm("
  172.     movel    sp@(4),d0
  173.     mulsl    sp@(8),d0
  174.     rts
  175. ");
  176. #endif
  177.  
  178. /* unsigned / unsigned */
  179. #if defined(L__udivsi3) || defined(ALL)
  180. ENTRY(__udivsi3)
  181. asm("
  182.     movel    sp@(4),d0
  183.     divul    sp@(8),d0
  184.     rts
  185. ");
  186. #endif
  187.  
  188. /* unsigned % unsigned */
  189. #if defined(L__umodsi3) || defined(ALL)
  190. ENTRY(__umodsi3)
  191. asm("
  192.     movel    sp@(4),d1
  193.     divull    sp@(8),d0:d1
  194.     rts
  195. ");
  196. #endif
  197.  
  198. /* unsigned * unsigned */
  199. #if defined(L__umulsi3) || defined(ALL)
  200. ENTRY(__umulsi3)
  201. asm("
  202.     movel    sp@(4),d0
  203.     mulul    sp@(8),d0
  204.     rts
  205. ");
  206. #endif
  207.  
  208.  
  209. #else
  210.  
  211.  
  212. #if defined(L__divsi3) || defined(ALL)
  213. SItype __divsi3 (SItype a, SItype b)
  214. {
  215.   unsigned SItype q, r;
  216.   int neg = (a < 0) != (b < 0);
  217.  
  218.   if (a < 0) a = -a;
  219.   if (b < 0) b = -b;
  220.  
  221.   divmodu (q, r, a, b);
  222.  
  223.   return neg ? -q : q;
  224. }
  225. #endif
  226.  
  227. #if defined(L__modsi3) || defined(ALL)
  228. SItype __modsi3 (SItype a, SItype b)
  229. {
  230.   unsigned SItype q, r;
  231.   int neg = (a < 0);
  232.  
  233.   if (a < 0) a = -a;
  234.   if (b < 0) b = -b;
  235.  
  236.   divmodu (q, r, a, b);
  237.  
  238.   return neg ? -r : r;
  239. }
  240. #endif
  241.  
  242. #if defined(L__mulsi3) || defined(ALL)
  243. SItype __mulsi3 (SItype a, SItype b)
  244. {
  245.   int neg = (a < 0) != (b < 0);
  246.   SItype res;
  247.  
  248.   if (a < 0) a = -a;
  249.   if (b < 0) b = -b;
  250.   
  251.   res = mulu (a,b);
  252.   return neg ? -res : res;
  253. }
  254. #endif
  255.  
  256. #if defined(L__udivsi3) || defined(ALL)
  257. unsigned SItype __udivsi3 (unsigned SItype a, unsigned SItype b)
  258. {
  259.   unsigned SItype q, r;
  260.   divmodu (q, r, a, b);
  261.   return q;
  262. }
  263. #endif
  264.  
  265. #if defined(L__umodsi3) || defined(ALL)
  266. unsigned SItype __umodsi3 (unsigned SItype a, unsigned SItype b)
  267. {
  268.   unsigned SItype q, r;
  269.   divmodu (q, r, a, b);
  270.   return r;
  271. }
  272. #endif
  273.  
  274. #endif
  275.  
  276. /* -double */
  277. #if defined(L__negdf2) || defined(ALL)
  278. ENTRY(__negdf2)
  279. asm("
  280.     movel    sp@(4),d0
  281.     movel    sp@(8),d1
  282.     bchg    #31,d0
  283.     rts
  284. ");
  285. #endif
  286.  
  287. /* -single */
  288. #if defined(L__negsf2) || defined(ALL)
  289. ENTRY(__negsf2)
  290. asm("
  291.     movel    sp@(4),d0
  292.     bchg    #31,d0
  293.     rts
  294. ");
  295. #endif
  296.  
  297.  
  298.  
  299. #ifdef __HAVE_68881__
  300.  
  301. /* double + double */
  302. #if defined(L__adddf3) || defined(ALL)
  303. ENTRY(__adddf3)
  304. asm("
  305.     fmoved    sp@(4),fp0
  306.     faddd    sp@(12),fp0
  307.     fmoved    fp0,sp@-
  308.     movel    sp@+,d0
  309.     movel    sp@+,d1
  310.     rts
  311. ");
  312. #endif
  313.  
  314. /* single + single */
  315. #if defined(L__addsf3) || defined(ALL)
  316. ENTRY(__addsf3)
  317. asm("
  318.     fmoves    sp@(4),fp0
  319.     fadds    sp@(8),fp0
  320.     fmoves    fp0,d0
  321.     rts
  322. ");
  323. #endif
  324.  
  325. /* double > double: 1 */
  326. /* double < double: -1 */
  327. /* double == double: 0 */
  328. #if defined(L__cmpdf2) || defined(ALL)
  329. ENTRY(__cmpdf2)
  330. asm("
  331.     fmoved    sp@(4),fp0
  332.     fcmpd    sp@(12),fp0
  333.     fbgt    Lagtb1
  334.     fslt    d0
  335.     extbl    d0
  336.     rts
  337. Lagtb1:
  338.     moveq    #1,d0
  339.     rts
  340. ");
  341. #endif
  342.  
  343. /* single > single: 1 */
  344. /* single < single: -1 */
  345. /* single == single: 0 */
  346. #if defined(L__cmpsf2) || defined(ALL)
  347. ENTRY(__cmpsf2)
  348. asm("
  349.     fmoves    sp@(4),fp0
  350.     fcmps    sp@(8),fp0
  351.     fbgt    Lagtb2
  352.     fslt    d0
  353.     extbl    d0
  354.     rts
  355. Lagtb2:
  356.     moveq    #1,d0
  357.     rts
  358. ");
  359. #endif
  360.  
  361. /* double / double */
  362. #if defined(L__divdf3) || defined(ALL)
  363. ENTRY(__divdf3)
  364. asm("
  365.     fmoved    sp@(4),fp0
  366.     fdivd    sp@(12),fp0
  367.     fmoved    fp0,sp@-
  368.     movel    sp@+,d0
  369.     movel    sp@+,d1
  370.     rts
  371. ");
  372. #endif
  373.  
  374. /* single / single */
  375. #if defined(L__divsf3) || defined(ALL)
  376. ENTRY(__divsf3)
  377. asm("
  378.     fmoves    sp@(4),fp0
  379.     fdivs    sp@(8),fp0
  380.     fmoves    fp0,d0
  381.     rts
  382. ");
  383. #endif
  384.  
  385. /* (double) float */
  386. #if defined(L__extendsfdf2) || defined(ALL)
  387. ENTRY(__extendsfdf2)
  388. asm("
  389.     fmoves    sp@(4),fp0
  390.     fmoved    fp0,sp@-
  391.     movel    sp@+,d0
  392.     movel    sp@+,d1
  393.     rts
  394. ");
  395. #endif
  396.  
  397. #if defined(Lfabs) || defined(ALL)
  398. ENTRY(fabs)
  399. asm("
  400.     fmoved    sp@(4),fp0
  401.     fjnlt    L1
  402.     fnegx    fp0
  403. L1:
  404.     fmoved    fp0,sp@-
  405.     movel    sp@+,d0
  406.     movel    sp@+,d1
  407.     rts
  408. ");
  409. #endif
  410.  
  411. /* (int) double */
  412. #if defined(L__fixdfsi) || defined(ALL)
  413. ENTRY(__fixdfsi)
  414. asm("
  415.     fintrzd    sp@(4),fp0
  416.     fmovel    fp0,d0
  417.     rts
  418. ");
  419. #endif
  420.  
  421. /* (double) int */
  422. #if defined(L__floatsidf) || defined(ALL)
  423. ENTRY(__floatsidf)
  424. asm("
  425.     fmovel    sp@(4),fp0
  426.     fmoved    fp0,sp@-
  427.     movel    sp@+,d0
  428.     movel    sp@+,d1
  429.     rts
  430. ");
  431. #endif
  432.  
  433. /*
  434.  * double frexp(val, eptr)
  435.  * returns: x s.t. val = x * (2 ** n), with n stored in *eptr
  436.  */
  437. #if defined(Lfrexp) || defined(ALL)
  438. ENTRY(frexp)
  439. asm("
  440.     fmoved        sp@(4),fp1
  441.     fgetmanx    fp1,fp0
  442.     fgetexpx    fp1
  443.     fmovel        fp1,d0
  444.     addql        #1,d0
  445.     movel        sp@(12),a0
  446.     movel        d0,a0@
  447.     fdivl        #2,fp0
  448.     fmoved        fp0,sp@-
  449.     movel        sp@+,d0
  450.     movel        sp@+,d1
  451.     rts
  452. ");
  453. #endif
  454.  
  455. /*
  456.  * double ldexp(val, exp)
  457.  * returns: val * (2**exp), for integer exp
  458.  */
  459. #if defined(Lldexp) || defined(ALL)
  460. ENTRY(ldexp)
  461. asm("
  462.     fmoved        sp@(4),fp0
  463.     fbeq        Ldone
  464.     ftwotoxl    sp@(12),fp1
  465.     fmulx        fp1,fp0
  466. Ldone:
  467.     fmoved        fp0,sp@-
  468.     movel        sp@+,d0
  469.     movel        sp@+,d1
  470.     rts
  471. ");
  472. #endif
  473.  
  474. /*
  475.  * double modf(val, iptr)
  476.  * returns: xxx and n (in *iptr) where val == n.xxx
  477.  */
  478. #if defined(Lmodf) || defined(ALL)
  479. ENTRY(modf)
  480. asm("
  481.     fmoved    sp@(4),fp0
  482.     movel    sp@(12),a0
  483.     fintrzx    fp0,fp1
  484.     fmoved    fp1,a0@
  485.     fsubx    fp1,fp0
  486.     fmoved    fp0,sp@-
  487.     movel    sp@+,d0
  488.     movel    sp@+,d1
  489.     rts
  490. ");
  491. #endif
  492.  
  493. /* double * double */
  494. #if defined(L__muldf3) || defined(ALL)
  495. ENTRY(__muldf3)
  496. asm("
  497.     fmoved    sp@(4),fp0
  498.     fmuld    sp@(12),fp0
  499.     fmoved    fp0,sp@-
  500.     movel    sp@+,d0
  501.     movel    sp@+,d1
  502.     rts
  503. ");
  504. #endif
  505.  
  506. /* single * single */
  507. #if defined(L__mulsf3) || defined(ALL)
  508. ENTRY(__mulsf3)
  509. asm("
  510.     fmoves    sp@(4),fp0
  511.     fmuls    sp@(8),fp0
  512.     fmoves    fp0,d0
  513.     rts
  514. ");
  515. #endif
  516.  
  517. /* double - double */
  518. #if defined(L__subdf3) || defined(ALL)
  519. ENTRY(__subdf3)
  520. asm("
  521.     fmoved    sp@(4),fp0
  522.     fsubd    sp@(12),fp0
  523.     fmoved    fp0,sp@-
  524.     movel    sp@+,d0
  525.     movel    sp@+,d1
  526.     rts
  527. ");
  528. #endif
  529.  
  530. /* single - single */
  531. #if defined(L__subsf3) || defined(ALL)
  532. ENTRY(__subsf3)
  533. asm("
  534.     fmoves    sp@(4),fp0
  535.     fsubs    sp@(8),fp0
  536.     fmoves    fp0,d0
  537.     rts
  538. ");
  539. #endif
  540.  
  541. /* (float) double */
  542. #if defined(L__truncdfsf2) || defined(ALL)
  543. ENTRY(__truncdfsf2)
  544. asm("
  545.     fmoved    sp@(4),fp0
  546.     fmoves    fp0,d0
  547.     rts
  548. ");
  549. #endif
  550.  
  551. #else /* __HAVE_68881__ */
  552.  
  553. #if defined(L__adddf3) || defined(ALL)
  554. double __adddf3 (double a, double b)
  555. {
  556.   return IEEEDPAdd (a, b);
  557. }
  558. #endif
  559.  
  560. #if defined(L__addsf3) || defined(ALL)
  561. SFVALUE __addsf3 (FLOAT a, FLOAT b)
  562. {
  563.   return IEEESPAdd (a, b);
  564. }
  565. #endif
  566.  
  567. #if defined(L__cmpdf2) || defined(ALL)
  568. int __cmpdf2 (double a, double b)
  569. {
  570.   return ieeedpcmp (a, b);
  571. }
  572. #endif
  573.  
  574. #if defined(L__cmpsf2) || defined(ALL)
  575. int __cmpsf2 (FLOAT a, FLOAT b)
  576. {
  577.   return IEEESPCmp (a, b);
  578. }
  579. #endif
  580.  
  581. #if defined(L__divdf3) || defined(ALL)
  582. double __divdf3 (double a, double b)
  583. {
  584.   return IEEEDPDiv (a, b);
  585. }
  586. #endif
  587.  
  588. #if defined(L__divsf3) || defined(ALL)
  589. SFVALUE __divsf3 (FLOAT a, FLOAT b)
  590. {
  591.   return IEEESPDiv (a, b);
  592. }
  593. #endif
  594.  
  595. #if defined(L__extendsfdf2) || defined(ALL)
  596. double __extendsfdf2 (FLOAT a)
  597. {
  598.   return IEEEDPFieee(a);
  599. }
  600. #endif
  601.  
  602. #if defined(Lfabs) || defined(ALL)
  603. double fabs (double d)
  604. {
  605.   return d < 0.0 ? -d : d;
  606. }
  607. #endif
  608.  
  609. #if defined(L__fixdfsi) || defined(ALL)
  610. SItype __fixdfsi (double a)
  611. {
  612.   return IEEEDPFix (a);
  613. }
  614. #endif
  615.  
  616. #if defined(L__floatsidf) || defined(ALL)
  617. double __floatsidf (SItype a)
  618. {
  619.   return IEEEDPFlt (a);
  620. }
  621. #endif
  622.  
  623. /*
  624.  *    the call
  625.  *        x = frexp(arg,&exp);
  626.  *    must return a double fp quantity x which is <1.0
  627.  *    and the corresponding binary exponent "exp".
  628.  *    such that
  629.  *        arg = x*2^exp
  630.  *    if the argument is 0.0, return 0.0 mantissa and 0 exponent.
  631.  */
  632.  
  633. #if defined(Lfrexp) || defined(ALL)
  634. double frexp (double x, int *i)
  635. {
  636.   int neg = 0;
  637.   int j = 0;
  638.  
  639.   if (x < 0)
  640.     {
  641.       x = -x;
  642.       neg = 1;
  643.     }
  644.  
  645.   if (x >= 1.0)
  646.     while (x >= 1.0)
  647.       {
  648.     j = j + 1;
  649.     x = x / 2;
  650.       }
  651.   else if (x < 0.5 && x != 0.0)
  652.     while (x < 0.5)
  653.       {
  654.     j = j - 1;
  655.     x = 2 * x;
  656.       }
  657.  
  658.   *i = j;
  659.   if (neg)
  660.     x = -x;
  661.   return x;
  662. }
  663. #endif
  664.  
  665. #if defined(Lldexp) || defined(ALL)
  666. /*
  667.  * ldexp returns the quanity "value" * 2 ^ "exp"
  668.  *
  669.  * For the mc68000 using IEEE format the double precision word format is:
  670.  *
  671.  * WORD N   =>    SEEEEEEEEEEEMMMM
  672.  * WORD N+1 =>    MMMMMMMMMMMMMMMM
  673.  * WORD N+2 =>    MMMMMMMMMMMMMMMM
  674.  * WORD N+3 =>    MMMMMMMMMMMMMMMM
  675.  *
  676.  * Where:          S  =>   Sign bit
  677.  *                 E  =>   Exponent
  678.  *                 X  =>   Ignored (set to 0)
  679.  *                 M  =>   Mantissa bit
  680.  *
  681.  * NOTE:  Beware of 0.0; on some machines which use excess 128 notation for the
  682.  * exponent, if the mantissa is zero the exponent is also.
  683.  *
  684.  */
  685.  
  686. #define MANT_MASK 0x800FFFFF    /* Mantissa extraction mask     */
  687. #define ZPOS_MASK 0x3FF00000    /* Positive # mask for exp = 0  */
  688. #define ZNEG_MASK 0x3FF00000    /* Negative # mask for exp = 0  */
  689.  
  690. #define EXP_MASK 0x7FF00000    /* Mask for exponent            */
  691. #define EXP_SHIFTS 20        /* Shifts to get into LSB's     */
  692. #define EXP_BIAS 1023        /* Exponent bias                */
  693.  
  694. union dtol
  695. {
  696.   double dval;
  697.   int ival[2];
  698. };
  699.  
  700. double ldexp (double value, int exp)
  701. {
  702.   union dtol number;
  703.   int *iptr, cexp;
  704.  
  705.   if (value == 0.0)
  706.     return (0.0);
  707.   number.dval = value;
  708.   iptr = &number.ival[0];
  709.   cexp = (((*iptr) & EXP_MASK) >> EXP_SHIFTS) - EXP_BIAS;
  710.   *iptr &= ~EXP_MASK;
  711.   exp += EXP_BIAS;
  712.   *iptr |= ((exp + cexp) << EXP_SHIFTS) & EXP_MASK;
  713.   return (number.dval);
  714. }
  715. #endif
  716.  
  717. /*
  718.  * modf(value, iptr): return fractional part of value, and stores the
  719.  * integral part into iptr (a pointer to double).
  720.  */
  721.  
  722. #if defined(Lmodf) || defined(ALL)
  723. double modf (double value, double *iptr)
  724. {
  725.   /* if value negative */
  726.   if (IEEEDPTst (value) < 0)
  727.     {
  728.       /* in that case, the integer part is calculated by ceil() */
  729.       *iptr = IEEEDPCeil (value);
  730.       return IEEEDPSub (*iptr, value);
  731.     }
  732.   else
  733.     {
  734.       /* if positive, we go for the floor() */
  735.       *iptr = IEEEDPFloor (value);
  736.       return IEEEDPSub (value, *iptr);
  737.     }
  738. }
  739. #endif
  740.  
  741. #if defined(L__muldf3) || defined(ALL)
  742. double __muldf3 (double a, double b)
  743. {
  744.   return IEEEDPMul (a, b);
  745. }
  746. #endif
  747.  
  748. #if defined(L__mulsf3) || defined(ALL)
  749. SFVALUE __mulsf3 (FLOAT a, FLOAT b)
  750. {
  751.   return IEEESPMul (a, b);
  752. }
  753. #endif
  754.  
  755. #if defined(L__subdf3) || defined(ALL)
  756. double __subdf3 (double a, double b)
  757. {
  758.   return IEEEDPSub (a, b);
  759. }
  760. #endif
  761.  
  762. #if defined(L__subsf3) || defined(ALL)
  763. SFVALUE __subsf3 (FLOAT a, FLOAT b)
  764. {
  765.   return IEEESPSub (a, b);
  766. }
  767. #endif
  768.  
  769. #if defined(L__truncdfsf2) || defined(ALL)
  770. SFVALUE __truncdfsf2 (double a)
  771. {
  772.   return IEEEDPTieee(a);
  773. }
  774. #endif
  775.  
  776. #endif /* __HAVE_68881__ */
  777.